#include<sys/socket.h>
#include<sys/types.h>
#include<netinet/in.h>
#include<arpa/inet.h>

#include<iostream>
#include<cstring>
#include<unistd.h>
#include<signal.h>
using namespace std;

void ServiceIO(int new_socket)
{
    while(true)
    {
        char buffer[1024];
        memset(buffer, 0, sizeof(buffer));
        //读取client传过来的信息
        ssize_t s = read(new_socket, buffer, sizeof(buffer)-1);
        if(s > 0)
        {
            buffer[s] = 0;//将获取的内容当成字符串
            cout << "client# " << buffer << endl;
            //用获取到的字符串构建新的字符串
            string echo_string = ">>server<<";
            echo_string += buffer;
            //将构建好的字符串发送给client
            write(new_socket, echo_string.c_str(), echo_string.size());
        }
        else if(s == 0)//read返回值为0，相当于对端连接关闭了
        {
            cout << "client quit..." << endl;
            break;
        }
        else
        {
            cout << "server read err" << endl;
            break;
        }
    }
}

void Usage(string proc)
{
    cout << "Usage: " << proc << " port" << endl;
}

// ./server_tcp port
int main(int argc, char* argv[])
{
    if(argc != 2)
    {
        Usage(argv[0]);
        return 1;
    }
    //1.socket创建套接字
    int listen_sock = socket(AF_INET, SOCK_STREAM, 0);
    if(listen_sock < 0)
    {
        cout << "server socket err" << endl;
        return 2;
    }

    //2.bind将套接字文件描述符、端口号和IP绑到一起
    // 填充sockaddr_in
    struct sockaddr_in local;
    memset(&local, 0, sizeof(local));//清空结构体变量
    local.sin_family = AF_INET;
    local.sin_port = htons(atoi(argv[1]));
    local.sin_addr.s_addr = INADDR_ANY;
    // 开始bind
    if(bind(listen_sock, (struct sockaddr*)&local, sizeof(local)) < 0)
    {
        cout << "server bind err" << endl;
        return 3;
    }

    //3.listen启动监听，设置套接字为listen状态，本质是允许用户连接(能不能通信先不说)

    //  因为tcp是面向连接的，所以在通信前，首先要建立链接，然后才能通信

    // 一定要有人主动建立连接(客户端，需要服务)，一定有人被动接收连接(服务器，提供服务)。
    // 我们当前写的是一个server，所以要，周而复始的不间断的等待客户到来，要不间断的给
    // 用户提供一个建立连接的功能
    const int back_log = 5;
    if(listen(listen_sock, back_log) < 0)//给listen_sock启动监听，监听：等客户端连接
    {
        cout << "server listen err" << endl;
        return 4;
    }

    //方案一：
    //当子进程退出，会给父进程发送一个SIGCHLD信号，让父进程忽略子进程的SIGCHLD信号，
    //则子进程会自动退出并释放资源
    signal(SIGCHLD, SIG_IGN);

    //4.accept接收连接的套接字，然后提供服务
    for( ; ; )
    {
        struct sockaddr_in peer;//输出对端的socket信息
        socklen_t len = sizeof(peer);
        //new_socket：真正提供服务的套接字  listen_sock：监听套接字
        int new_socket = accept(listen_sock, (struct sockaddr*)&peer, &len);
        if(new_socket < 0)
        {
            continue;
        }
        //取出对端的IP和port
        uint16_t cli_port = ntohs(peer.sin_port);
        string cli_ip = inet_ntoa(peer.sin_addr);
        //打印对端IP、port、new_socket
        cout << "get a new link, IP:" << cli_ip << " port:" << cli_port << " new_socket:" << new_socket << endl;
        //5.提供服务
        pid_t id = fork();
        //如果是单进程（单线程），没人使用，因为任何时刻只支持给一个人提供服务
        //所以要创建子进程，让子进程去提供服务，而父进程继续去accept新的连接
        if(id < 0)
        {
            cout << "server fork err" << endl;
            return 5;
        }
        else if(id == 0)
        {
            //child，开始提供服务
            ServiceIO(new_socket);
            //关闭文件描述符，防止文件描述符泄漏
            close(new_socket);
        }
        else
        {
            //parent，do nothing
            //父进程需要继续上去accept接受客户端的连接，所以不能阻塞等待，
            //因为子进程把服务提供完毕才能完成等待，如果阻塞等待了，结果就
            //还是同时只能给一个人提供服务
            //方案一：
            //当子进程退出，会给父进程发送一个SIGCHLD信号，
            //让父进程忽略子进程的SIGCHLD信号，则子进程会自动退出并释放资源
        }
    }
    return 0;
}

